A Forest Representation for Evolutionary Algorithms Applied to Network Design

Network design involves several areas of engineering and science. Computer networks, electrical circuits, transportation problems, and phylogenetic trees are some examples. In general, these problems are NP-Hard. In order to deal with the complexity of these problems, several strategies have been proposed. Among them, approaches using evolutionary algorithms have achieved relevant results. However, the graph encoding is critical for the performance of such approaches in network design problems. Aiming to overcome this drawback, alternative representations of spanning trees have been developed. This article proposes an encoding for generation of spanning forests by evolutionary algorithms. 1 The Proposed Representation The proposed forest representation basically consists of linear lists (which may be an array T ) containing the tree nodes and their depths. The order the pairs (node,depth) are disposed in the list is important and it must follow a preorder traversal. The forest representation is composed by the union of the encodings of all trees of a forest. Two operators are proposed (named operator 1 and operator 2) to generate new spanning forests using the node-depth encoding. Both operators generate a spanning forest F ′ of a graph G when they are applied to another spanning forest F of G. The results produced by the application of the operators are similar. The application of the operator 1 (or 2) to a forest is equivalent to transfer a subtree from a tree Tfrom to another tree Tto of the same forest. Applying operator 1, the root of the pruned subtree will be also the root of this subtree in its new tree (Tto). On the other hand, the transferred subtree will have a new root when applying operator 2. In the description of the operator 1, we consider that two nodes were previously chosen: the prune node p, which indicates the root of the subtree of Tfrom to be transferred; and the adjacent node a, which is a node of a tree different from Tfrom. This node is also adjacent to p in G. An efficient procedure to determine such nodes are proposed in [1]. Besides, we assume that the node-depth representation was implemented using arrays and that the indices of p (ip) and a (ia), respectively, in the arrays Tfrom and Tto are also known. The operator 1 can be described by the following steps: E. Cantú-Paz et al. (Eds.): GECCO 2003, LNCS 2723, pp. 634–635, 2003. c © Springer-Verlag Berlin Heidelberg 2003 A Forest Representation for Evolutionary Algorithms 635 1. Determine the range (ip-il) of indices in Tfrom corresponding to the subtree rooted at node p. Since we know ip, we only need to find il; 2. Copy the data in the range ip-il from Tfrom into a temporary array Ttmp (corresponding to the subtree being transferred) and update the node depths using the depth of a. 3. Create an array T ′ to (new tree) copying Tto and inserting Ttmp (pruned subtree) after the node a in Tto. 4. Construct an array T ′ from copying Tfrom without the nodes of Ttmp. 5. Copy the forest F to F ′ exchanging the pointers to Tfrom and Tto for pointers to T ′ from and T ′ to, respectively. The operator 2 requires a new root node r, besides the nodes p and a. The copy of the pruned subtree for the operator 2 can be divided in two steps: The first step corresponds to the step 2 for the operator 1 exchanging the range ipil by ir-il. The array returned by this procedure is named Ttmp1. The second step considers the nodes in the path from r to p (i.e. r0, r1, r2, . . ., rn, where r0 = r and rn = p) as roots of subtrees. The subtree rooted at r1 contains the subtree rooted at r0. The subtree rooted at r2 contains the subtree rooted at r1, and so on. The algorithm for the second step copies the subtrees rooted at rj (j = 1, . . . , n) without the subtree rooted at rj−1, updates the depths 1, and store the resultant subtrees in a temporary array Ttmp2. The step 3 of the operator 2 is equivalent to the same step of the operator 1, exchanging Ttmp for the concatenation of Ttmp1 and Ttmp2 (Ttmp = [Ttmp1|Ttmp2]). The steps 4 and 5 are equal in both operators. 2 Final Considerations This proposal focuses on the production of spanning forests instead of trees (usually found in the literature). As consequence, the operator complexity depends on, for example, the size of the modified trees from F to F ′, while the complexity of the operators found in the literature are usually functions of the number of nodes and/or edges in the underlying graph. The proposed operators do not require a graph G to be complete in order to produce only feasible spanning forests of G. Many practical problems do not involve complete graphs (in fact, several networks correspond to sparse graphs).